Výkonnosť webových frameworkov: Benchmark Flask vs Django vs FastAPI

Výber správneho webového frameworku je kľúčový pre budovanie efektívnych a škálovateľných webových aplikácií. Python ponúka niekoľko vynikajúcich možností, z ktorých každá má svoje silné a slabé stránky. Tento článok poskytuje komplexný benchmark porovnávajúci tri populárne frameworky: Flask, Django a FastAPI. Budeme analyzovať ich výkonnostné charakteristiky, využitie zdrojov a vhodnosť pre rôzne typy aplikácií, pričom zohľadníme globálne vývojové postupy a prostredia pre nasadenie.

Úvod

Webové frameworky poskytujú štruktúrované prostredie na tvorbu webových aplikácií, pričom sa starajú o úlohy ako smerovanie, spracovanie požiadaviek a interakciu s databázou. Voľba frameworku výrazne ovplyvňuje výkonnosť aplikácie, najmä pri vysokej záťaži. Cieľom tohto benchmarku je poskytnúť dáta, ktoré pomôžu vývojárom robiť informované rozhodnutia.

• Flask: Mikroframework, ktorý ponúka jednoduchosť a flexibilitu. Je to dobrá voľba pre malé až stredne veľké projekty, kde potrebujete jemnú kontrolu.
• Django: Plnohodnotný framework poskytujúci komplexný súbor nástrojov a funkcií vrátane ORM, šablónovacieho systému a administrátorského rozhrania. Je vhodný pre zložité aplikácie vyžadujúce robustnú a škálovateľnú architektúru.
• FastAPI: Moderný, vysokovýkonný framework postavený na ASGI, navrhnutý na rýchle a efektívne budovanie API. Vyniká v asynchrónnych operáciách a je silným kandidátom pre mikroservisy a aplikácie s vysokou priepustnosťou.

Nastavenie benchmarku

Aby sme zabezpečili spravodlivé a presné porovnanie, použijeme štandardizované nastavenie benchmarku. To zahŕňa:

• Hardvér: Dedikovaný server s konzistentnými špecifikáciami (napr. CPU, RAM, úložisko). Presné špecifikácie budú uvedené a zostanú konštantné počas všetkých testov.
• Softvér: Najnovšie stabilné verzie Pythonu, Flasku, Djanga a FastAPI. Použijeme konzistentnú verziu Gunicornu a Uvicornu pre WSGI/ASGI servery.
• Databáza: PostgreSQL, populárna open-source relačná databáza, nakonfigurovaná pre optimálny výkon.
• Nástroj na záťažové testovanie: Locust, nástroj na záťažové testovanie založený na Pythone, použitý na simuláciu súbežných používateľov a meranie výkonnosti aplikácie.
• Nástroje na monitorovanie: Prometheus a Grafana na monitorovanie využitia zdrojov servera (CPU, pamäť, sieť).
• Testovacie prípady: Zadefinujeme niekoľko testovacích prípadov, ktoré reprezentujú bežné scenáre webových aplikácií:
• Hello World: Jednoduchý endpoint, ktorý vracia statický reťazec. Testuje základnú réžiu frameworku pri smerovaní a spracovaní požiadaviek.
• Čítanie z databázy: Endpoint, ktorý získava dáta z databázy. Testuje výkonnosť ORM (alebo vrstvy interakcie s databázou) frameworku.
• Zápis do databázy: Endpoint, ktorý zapisuje dáta do databázy. Testuje výkonnosť ORM (alebo vrstvy interakcie s databázou) frameworku pri operáciách zápisu.
• Serializácia do JSON: Endpoint, ktorý serializuje dáta do formátu JSON. Testuje výkonnosť serializácie frameworku.

Detaily konfigurácie pre benchmarkovacie prostredie

• CPU: Intel Xeon E3-1231 v3 @ 3.40GHz
• RAM: 16GB DDR3
• Storage: 256GB SSD
• Operating System: Ubuntu 20.04
• Python: 3.9.7
• Flask: 2.0.1
• Django: 3.2.8
• FastAPI: 0.68.1
• Uvicorn: 0.15.0
• Gunicorn: 20.1.0
• PostgreSQL: 13.4

Úrovne súbežnosti: Aby sme dôkladne vyhodnotili výkonnosť, otestujeme každý framework pri rôznych úrovniach súbežnosti, od 10 do 500 súbežných používateľov. To nám umožní sledovať, ako sa každý framework škáluje pri zvyšujúcej sa záťaži.

Implementácie frameworkov

Pre každý framework vytvoríme jednoduchú aplikáciu, ktorá implementuje vyššie opísané testovacie prípady.

Flask

Flask používa WSGI toolkit Werkzeug. Pre interakciu s databázou použijeme SQLAlchemy, populárne ORM. Tu je zjednodušený príklad:

from flask import Flask, jsonify
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

app = Flask(__name__)

engine = create_engine('postgresql://user:password@host:port/database')
Base = declarative_base()

class Item(Base):
    __tablename__ = 'items'
    id = Column(Integer, primary_key=True)
    name = Column(String)

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

@app.route('/hello')
def hello_world():
    return 'Hello, World!'

@app.route('/item/')
def get_item(item_id):
    item = session.query(Item).get(item_id)
    if item:
        return jsonify({'id': item.id, 'name': item.name})
    else:
        return 'Item not found', 404

if __name__ == '__main__':
    app.run(debug=True)

Django

Django používa svoje vstavané ORM a šablónovací systém. Tu je zjednodušený príklad:

from django.http import JsonResponse, HttpResponse
from django.shortcuts import get_object_or_404
from django.db import models

class Item(models.Model):
    name = models.CharField(max_length=255)

def hello_world(request):
    return HttpResponse('Hello, World!')

def get_item(request, item_id):
    item = get_object_or_404(Item, pk=item_id)
    return JsonResponse({'id': item.id, 'name': item.name})

FastAPI

FastAPI je postavený na ASGI a používa Pydantic na validáciu dát. Na interakciu s databázou použijeme SQLAlchemy. Natívne podporuje asynchrónne spracovanie požiadaviek.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

app = FastAPI()

engine = create_engine('postgresql://user:password@host:port/database')
Base = declarative_base()

class Item(Base):
    __tablename__ = 'items'
    id = Column(Integer, primary_key=True)
    name = Column(String)

Base.metadata.create_all(engine)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

class ItemSchema(BaseModel):
    id: int
    name: str

@app.get('/hello')
async def hello_world():
    return 'Hello, World!'

@app.get('/item/{item_id}', response_model=ItemSchema)
async def read_item(item_id: int, db: SessionLocal = Depends(get_db)):
    item = db.query(Item).filter(Item.id == item_id).first()
    if item is None:
        raise HTTPException(status_code=404, detail='Item not found')
    return item

Výsledky benchmarku

Nasledujúce tabuľky zhrňujú výsledky benchmarku pre každý testovací prípad. Výsledky sú prezentované v počte požiadaviek za sekundu (RPS) a priemernej latencii (v milisekundách).

Hello World

Framework	Súbežnosť	RPS	Latencia (ms)
Flask	100	X	Y
Django	100	A	B
FastAPI	100	P	Q
Flask	500	Z	W
Django	500	C	D
FastAPI	500	R	S

Čítanie z databázy

Framework	Súbežnosť	RPS	Latencia (ms)
Flask	100	U	V
Django	100	E	F
FastAPI	100	T	U
Flask	500	NN	OO
Django	500	G	H
FastAPI	500	VV	XX

Zápis do databázy

Framework	Súbežnosť	RPS	Latencia (ms)
Flask	100	KK	LL
Django	100	I	J
FastAPI	100	YY	ZZ
Flask	500	MMM	PPP
Django	500	K	L
FastAPI	500	AAA	BBB

Serializácia do JSON

Framework	Súbežnosť	RPS	Latencia (ms)
Flask	100	QQ	RR
Django	100	M	N
FastAPI	100	CCC	DDD
Flask	500	SSS	TTT
Django	500	O	P
FastAPI	500	EEE	FFF

Poznámka: Nahraďte zástupné hodnoty (X, Y, A, B, atď.) skutočnými výsledkami benchmarku získanými po spustení testov. Tieto výsledky by sa vyplnili po spustení testov pomocou nástrojov Locust a ďalších monitorovacích nástrojov.

Analýza a interpretácia

Na základe výsledkov benchmarku (nahraďte zástupné symboly vašimi skutočnými dátami) môžeme vyvodiť nasledujúce závery:

• FastAPI všeobecne prekonáva Flask a Django v počte RPS a latencii, najmä pri vysokej súbežnosti. Je to vďaka jeho asynchrónnej povahe a optimalizovanej validácii dát pomocou Pydanticu.
• Flask poskytuje dobrú rovnováhu medzi výkonom a flexibilitou. Je to vhodná voľba pre menšie projekty alebo keď potrebujete jemnú kontrolu nad architektúrou aplikácie.
• Django, hoci je plnohodnotným frameworkom, môže vykazovať nižší výkon v porovnaní s FastAPI, najmä pri aplikáciách s veľkým počtom API volaní. Ponúka však bohatý súbor funkcií a nástrojov, ktoré môžu zjednodušiť vývoj zložitých projektov.
• Interakcie s databázou môžu byť úzkym hrdlom, bez ohľadu na použitý framework. Optimalizácia databázových dopytov a používanie kešovacích mechanizmov môže výrazne zlepšiť výkon.
• Réžia pri serializácii JSON môže ovplyvniť výkon, najmä pri endpointoch, ktoré vracajú veľké množstvo dát. Použitie efektívnych serializačných knižníc a techník môže pomôcť tento problém zmierniť.

Globálne aspekty a nasadenie

Pri nasadzovaní webových aplikácií globálne zvážte nasledujúce faktory:

• Geografické rozloženie: Použite Content Delivery Network (CDN) na kešovanie statických aktív a zníženie latencie pre používateľov v rôznych regiónoch.
• Umiestnenie databázy: Vyberte umiestnenie databázy, ktoré je geograficky blízko väčšiny vašich používateľov.
• Časové pásma: Správne spracovávajte časové pásma, aby sa dátumy a časy zobrazovali presne pre používateľov v rôznych regiónoch. Knižnice ako pytz sú nevyhnutné.
• Lokalizácia a internacionalizácia: Implementujte lokalizáciu a internacionalizáciu (i18n/l10n) na podporu viacerých jazykov a kultúr. Django má vstavanú podporu a Flask má rozšírenia ako Flask-Babel.
• Spracovanie mien: Uistite sa, že správne spracovávate rôzne meny vrátane formátovania a konverzných kurzov.
• Predpisy o ochrane osobných údajov: Dodržiavajte predpisy o ochrane osobných údajov, ako sú GDPR (Európa), CCPA (Kalifornia) a ďalšie, v závislosti od vašej cieľovej skupiny.
• Škálovateľnosť: Navrhnite svoju aplikáciu tak, aby sa mohla škálovať horizontálne a zvládnuť rastúcu návštevnosť z rôznych regiónov. Bežnými technikami sú kontajnerizácia (Docker) a orchestrácia (Kubernetes).
• Monitorovanie a logovanie: Implementujte komplexné monitorovanie a logovanie na sledovanie výkonnosti aplikácie a identifikáciu problémov v rôznych regiónoch.

Napríklad spoločnosť so sídlom v Nemecku, ktorá obsluhuje zákazníkov v Európe aj Severnej Amerike, by mala zvážiť použitie CDN s okrajovými lokalitami v oboch regiónoch, hosťovanie svojej databázy v regióne geograficky centrálnom pre svoju používateľskú základňu (napr. Írsko alebo východné pobrežie USA) a implementáciu i18n/l10n na podporu angličtiny a nemčiny. Mali by tiež zabezpečiť, aby ich aplikácia bola v súlade s GDPR a akýmikoľvek platnými zákonmi o ochrane súkromia v USA.

Záver

Výber webového frameworku závisí od špecifických požiadaviek vášho projektu. FastAPI ponúka vynikajúci výkon pre aplikácie s veľkým množstvom API volaní, zatiaľ čo Flask poskytuje flexibilitu a jednoduchosť. Django je robustný plnohodnotný framework vhodný pre zložité projekty. Dôkladne zhodnoťte požiadavky vášho projektu a zvážte výsledky benchmarku prezentované v tomto článku, aby ste urobili informované rozhodnutie.

Praktické odporúčania

• Spustite si vlastné benchmarky: Prispôsobte tieto testy vašim špecifickým prípadom použitia a infraštruktúre.
• Zvážte asynchrónne úlohy: Ak máte dlhotrvajúce úlohy, použite asynchrónne fronty úloh ako Celery.
• Optimalizujte databázové dopyty: Používajte indexovanie, kešovanie a efektívny návrh dopytov.
• Profilujte svoju aplikáciu: Použite nástroje na profilovanie na identifikáciu úzkych hrdiel.
• Monitorujte výkon: Pravidelne monitorujte výkon vašej aplikácie v produkcii.

Ďalšie čítanie

• Dokumentácia Flask
• Dokumentácia Django
• Dokumentácia FastAPI
• Dokumentácia Uvicorn
• Dokumentácia Gunicorn
• Dokumentácia Locust